其他
干掉 if else!
The following article is from Java后端 Author 王德印
作者丨王德印
来源丨Java后端(ID:web_resource)
if…else控制语句,如果代码里滥用会大大降低代码的可读性、可维护性、可扩展性以及灵活性,进而使整个软件系统造成危害。因为在实际的项目中,需求往往是不断变化的,新需求也层出不穷,因此违反了违反单一职责原则和开闭原则,而且有些公司的代码审查会通不过。
所以,if else的替代方案是很有必要的,如位语句,枚举,工厂模式,策略模式,状态模式等等。这里用一个场景详细说明if else的替代方案,大家用支付宝付款的时候,会有多种付款方式,如余额,花呗,余额宝,信用卡,银行卡。
01. 传统的方式public class PayDemo {
public String pay(String payType) {
String pay = "";
if ("1".equals(payType)) {
pay = "支付宝余额支付";
} else if ("2".equals(payType)) {
pay = "支付宝余额宝支付";
} else if ("3".equals(payType)) {
pay = "支付宝花呗支付";
} else {
pay = "其他支付";
}
//...
System.out.println(pay);
return pay;
}
}
public class PayTest {
public static void main(String[] args) {
PayDemo payDemo = new PayDemo();
payDemo.pay("1");
payDemo.pay("2");
payDemo.pay("3");
payDemo.pay("4");
}
}
枚举第一种
(1)面向接口编程,首先定义一个支付接口
public interface PayEnum {
String pay();
}
(2)定义一个具体的支付宝余额实现public class PayEnumByBalance implements PayEnum{
@Override
public String pay() {
System.out.println("支付宝余额支付");
return "支付宝余额支付";
}
}
(3)定义一个具体的支付宝花呗实现public class PayEnumByHuabei implements PayEnum {
@Override
public String pay() {
System.out.println("支付宝花呗支付");
return "支付宝花呗支付";
}
}
(4)定义一个具体的支付宝余额宝实现public class PayEnumByYuEBAO implements PayEnum {
@Override
public String pay() {
System.out.println("支付宝余额宝支付");
return "支付宝余额宝支付";
}
}
(5)定义一个枚举类public enum PayTypeEnum {
PAY_BALANCE("1",new PayEnumByBalance()),
PAY_HUABEI("2",new PayEnumByHuabei()),
PAY_YUEBAO("3",new PayEnumByYuEBAO());
private String payType;
private PayEnum payEnum;
PayTypeEnum(String payType, PayEnum payEnum) {
this.payType = payType;
this.payEnum = payEnum;
}
public static PayEnum getPay(String payType){
for (PayTypeEnum payTypeEnum : PayTypeEnum.values()) {
if (payTypeEnum.payType.equals(payType)) {
return payTypeEnum.payEnum;
}
}
return new PayEnumByBalance();
}
}
(6)客户端public class PayEnumTest {
public static void main(String[] args) {
PayEnum payEnum = PayTypeEnum.getPay("1");
payEnum.pay();
PayEnum payEnum1 = PayTypeEnum.getPay("2");
payEnum1.pay();
PayEnum payEnum2 = PayTypeEnum.getPay("3");
payEnum2.pay();
}
}
(7)结果:枚举第二种
(1) 面向接口编程,首先定义一个支付接口public interface PayEnum1 {
String pay();
}
(2)定义一个枚举类,并且实现支付接口public enum PayTypeEnum1 implements PayEnum1{
PAY_TYPE_BALANCE{
@Override
public String pay() {
System.out.println("支付宝余额支付");
return "支付宝余额支付";
}
},
PAY_TYPE_HUABEI{
@Override
public String pay() {
System.out.println("支付宝花呗支付");
return "支付宝花呗支付";
}
},
PAY_TYPE_YUEBAO{
@Override
public String pay() {
System.out.println("支付宝余额宝支付");
return "支付宝余额宝支付";
}
};
}
(3)客户端代码public class PayEnum1Test {
public static void main(String[] args) {
PayEnum1Test payEnum1Test = new PayEnum1Test();
payEnum1Test.pay("PAY_TYPE_BALANCE");
payEnum1Test.pay("PAY_TYPE_HUABEI");
payEnum1Test.pay("PAY_TYPE_YUEBAO");
}
public String pay(String payType){
return PayTypeEnum1.valueOf(payType).pay();
}
}
(4)结果:public interface PayFactory {
String pay();
}
public class PayFactoryByBalance implements PayFactory {
@Override
public String pay() {
System.out.println("支付宝余额支付");
return "支付宝余额支付";
}
}
public class PayFactoryByHuabei implements PayFactory {
@Override
public String pay() {
System.out.println("支付宝花呗支付");
return "支付宝花呗支付";
}
}
public class PayFactoryByYuEBAO implements PayFactory {
@Override
public String pay() {
System.out.println("支付宝余额宝支付");
return "支付宝余额宝支付";
}
}
public class PayTypeFactory {
private static Map<String,PayFactory> payTypeMap = new HashMap<>();
static {
payTypeMap.put("1",new PayFactoryByBalance());
payTypeMap.put("2",new PayFactoryByHuabei());
payTypeMap.put("3",new PayFactoryByYuEBAO());
}
public static PayFactory getPayType(String payType){
return payTypeMap.get(payType);
}
}
public class PayFactoryTest {
public static void main(String[] args) {
PayTypeFactory.getPayType("1").pay();
PayTypeFactory.getPayType("2").pay();
PayTypeFactory.getPayType("3").pay();
}
}
策略模式一句话就是,定义一系列算法,把他们封装起来,并且使它们可以相互替换。具体来说就说,定义多个策略对象,每个策略对象里面封装好多种算法,再定义一个上下文对象,该上下文对象负责根据传入不同的策略对象,执行不同的行为。
(1)定义一个抽象的公共策略接口Strategy,通常为接口,定义每个策略或算法必须具有的方法和属性。
public interface PayStrategy {
String pay();
}
(2)定义一个context对象,即扮演一个上下的文角色,起承上启下的封装作用,其行为随着策略对象改变而改变。
public class PayContext {
private PayStrategy payStrategy;
public PayContext(PayStrategy payStrategy) {
this.payStrategy = payStrategy;
}
public String executeStrategy(){
return payStrategy.pay();
}
}
public class PayStrategyByBalance implements PayStrategy {
@Override
public String pay() {
System.out.println("支付宝余额支付");
return "支付宝余额支付";
}
}
public class PayStrategyByHuabei implements PayStrategy {
@Override
public String pay() {
System.out.println("支付宝花呗支付");
return "支付宝花呗支付";
}
}
(5)定义一个具体的余额宝支付策略public class PayStrategyByYuEBAO implements PayStrategy {
@Override
public String pay() {
System.out.println("支付宝余额宝支付");
return "支付宝余额宝支付";
}
}
(6)客户端public class PayStrategyTest {
public static void main(String[] args) {
PayStrategyTest payStrategyTest = new PayStrategyTest();
payStrategyTest.method("1");
payStrategyTest.method("2");
payStrategyTest.method("3");
}
public void method(String payType){
PayContext payContext;
if ("1".equals(payType)){
payContext = new PayContext(new PayStrategyByHuabei());
payContext.executeStrategy();
}else if ("2".equals(payType)){
payContext = new PayContext(new PayStrategyByYuEBAO());
payContext.executeStrategy();
}else if ("3".equals(payType)){
payContext = new PayContext(new PayStrategyByBalance());
payContext.executeStrategy();
}
}
}
(7)结果:public class PayStrategyFactory {
private static Map<String, PayStrategy> payTypeMap = new HashMap<>();
static {
payTypeMap.put("1",new PayStrategyByBalance());
payTypeMap.put("2",new PayStrategyByYuEBAO());
payTypeMap.put("3",new PayStrategyByHuabei());
}
public static PayStrategy getPayType(String payType){
return payTypeMap.get(payType);
}
}
(9)再看客户端代码public class PayStrategyFactoryTest {
public static void main(String[] args) {
PayContext payContext = new PayContext(PayStrategyFactory.getPayType("1"));
payContext.executeStrategy();
PayContext payContext2 = new PayContext(PayStrategyFactory.getPayType("2"));
payContext2.executeStrategy();
PayContext payContext3 = new PayContext(PayStrategyFactory.getPayType("3"));
payContext3.executeStrategy();
}
}
运行结果还是一样的就不看了哈05. 状态模式+工厂模式
状态模式一句话来说就是,允许一个对象在其对象内部状态改变时改变它的行为。具体来讲,定义多种状态对象,和定义一个行为随着状态对象改变而改变的 context 对象。(1)面向接口编程,定义一个支付接口public interface PayState {
String pay(PayContext payContext);
}
(2)定义一个context上下文public class PayContext {
private PayState payState;
public PayContext() {
this.payState = null;
}
public void setPayState(PayState payState) {
this.payState = payState;
}
public PayState getPayState() {
return payState;
}
}
(2)定义具体的状态类public class PayStateByBalance implements PayState {
@Override
public String pay(PayContext payContext) {
System.out.println("支付宝余额支付");
payContext.setPayState(this);
return "支付宝余额支付";
}
}
public class PayStateByHuabei implements PayState {
@Override
public String pay(PayContext payContext) {
System.out.println("支付宝花呗支付");
payContext.setPayState(this);
return "支付宝花呗支付";
}
}
public class PayStateByYuEBAO implements PayState {
@Override
public String pay(PayContext payContext) {
System.out.println("支付宝余额宝支付");
payContext.setPayState(this);
return "支付宝余额宝支付";
}
}
public class PayStateTest {
public static void main(String[] args) throws InterruptedException {
PayStateTest payStateTest = new PayStateTest();
payStateTest.method("1");
payStateTest.method("2");
payStateTest.method("3");
}
public void method(String payType){
PayContext context = new PayContext();
if ("1".equals(payType)) {
PayStateByBalance payStateByBalance = new PayStateByBalance();
payStateByBalance.pay(context);
}else if("2".equals(payType)) {
PayStateByHuabei payStateByHuabei = new PayStateByHuabei();
payStateByHuabei.pay(context);
}else if("3".equals(payType)) {
PayStateByYuEBAO payStateByYuEBAO = new PayStateByYuEBAO();
payStateByYuEBAO.pay(context);
}
}
}
(4)结果:public class PayStateFactory {
private static Map<String, PayState> payTypeMap = new HashMap<>();
static {
payTypeMap.put("1",new PayStateByBalance());
payTypeMap.put("2",new PayStateByYuEBAO());
payTypeMap.put("3",new PayStateByHuabei());
}
public static PayState getPayType(String payType){
return payTypeMap.get(payType);
}
}
(6)再看客户端代码public class PayStateFactoryTest {
public static void main(String[] args) {
PayContext context = new PayContext();
PayStateFactory.getPayType("1").pay(context);
PayStateFactory.getPayType("2").pay(context);
PayStateFactory.getPayType("3").pay(context);
}
}
总结:完全解决了代码中的 if else,本文作者:王德印,欢迎复制下方链接关注博主动态。链接:https://blog.csdn.net/qq_41889508/article/details/105953114
点分享
点点赞
点在看